/**
 * 用法：
 * 玉衡杯原神改动记录
 * 玉衡杯星铁改动记录
 * 玉衡杯原神菈乌玛
 * 玉衡杯星铁白厄
 */
import plugin from '../../lib/plugins/plugin.js'
// pnpm i got-scraping
import { gotScraping } from 'got-scraping'
import vm from 'vm'


const groupId = '450977050' // 这里填写需要推送的QQ群号

export class example extends plugin {
  constructor () {
    super({
      name: 'ys-玉衡杯',
      dsc: 'ys-玉衡杯',
      event: 'message',
      priority: 5000,
      rule: [
        {
          reg: '^玉衡杯.*$',
          fnc: 'main'
        },
        {
          reg: '^#重置玉衡杯推送记录$',
          fnc: 'resetPushRecord'
        },
        {
          reg: '^#手动推送玉衡杯更新$',
          fnc: 'manualPushUpdate'
        }
      ]
    })

    // 添加定时任务：每30分钟检查版本更新
    this.task = {
      cron: '0 */30 * * * *',
      name: 'ys-玉衡杯版本检查',
      fnc: () => this.checkVersionUpdate(),
      log: false
    }

    // Redis键名常量
    this.REDIS_KEYS = {
      VERSION_PUSHED_GI: 'ys:yuhengjiu:version:pushed:GI',
      VERSION_PUSHED_HSR: 'ys:yuhengjiu:version:pushed:HSR'
    }

    // 通用请求头配置
    this.defaultHeaders = {
      'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
      'accept-language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6',
      'cache-control': 'max-age=0',
      'cookie': 'lang=CH; game=GI; __session:sessionID:=https:',
      'priority': 'u=0, i',
      'sec-ch-ua': '"Not)A;Brand";v="8", "Chromium";v="138", "Microsoft Edge";v="138"',
      'sec-ch-ua-mobile': '?0',
      'sec-ch-ua-platform': '"Windows"',
      'sec-fetch-dest': 'document',
      'sec-fetch-mode': 'navigate',
      'sec-fetch-site': 'none',
      'sec-fetch-user': '?1',
      'upgrade-insecure-requests': '1',
      'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0'
    }
  }

  // 通用请求方法
  async makeRequest (url, options = {}) {
    try {
      console.log(`🚀 开始请求: ${url}`)

      const response = await gotScraping({
        url: url,
        headers: { ...this.defaultHeaders, ...options.headers },
        http2: true,
        ...options
      })

      console.log('✅ 请求成功!')
      console.log('Status Code:', response.statusCode)

      return response
    } catch (error) {
      console.error('❌ 请求失败:', error.message)
      throw error
    }
  }

  // 版本检查定时任务
  async checkVersionUpdate () {
    try {
      console.log('开始检查版本更新...')

      // 获取版本信息
      const verResponse = await this.makeRequest('https://homdgcat.wiki/javascripts/ver.js')
      const verText = verResponse.body

      // 使用 vm 模块解析 JavaScript 代码
      const context = {}
      vm.createContext(context)
      vm.runInContext(verText, context)

      const { VER_GI, VER_SR, GI_DATES, SR_DATES } = context

      if (!VER_GI || !VER_SR || !GI_DATES || !SR_DATES) {
        console.error('无法解析版本信息')
        return
      }

      console.log(`当前版本 - 原神: ${VER_GI}, 星铁: ${VER_SR}`)

      const updates = []

      // 检查原神版本更新
      if (await this.checkGameVersionUpdate('GI', VER_GI, GI_DATES)) {
        updates.push({ game: 'GI', version: VER_GI, gameName: '原神' })
      }

      // 检查星铁版本更新
      if (await this.checkGameVersionUpdate('HSR', VER_SR, SR_DATES)) {
        updates.push({ game: 'HSR', version: VER_SR, gameName: '星铁' })
      }

      // 如果有更新，发送消息
      if (updates.length > 0) {
        await this.sendUpdateNotification(updates)
      } else {
        console.log('没有检测到版本更新')
      }

      console.log('版本检查完成')
    } catch (error) {
      console.error('版本检查失败:', error)
    }
  }

  // 检查单个游戏的版本更新
  async checkGameVersionUpdate (gameType, currentVersion, datesObject) {
    try {
      // 首先检查Redis中是否已经推送过这个版本
      const redisKey = gameType === 'GI' ? this.REDIS_KEYS.VERSION_PUSHED_GI : this.REDIS_KEYS.VERSION_PUSHED_HSR
      const pushedVersion = await redis.get(redisKey)

      if (pushedVersion === currentVersion) {
        console.log(`${gameType} ${currentVersion}: 该版本已经推送过，跳过`)
        return false
      }

      // 获取当前版本的开始时间（需要找到前一个版本的时间）
      const currentVersionStartTime = this.getCurrentVersionStartTime(currentVersion, datesObject)

      if (!currentVersionStartTime) {
        console.log(`${gameType} ${currentVersion}: 未找到对应的版本开始时间`)
        return false
      }

      const versionStartDate = new Date(currentVersionStartTime)
      const now = new Date()

      // 计算时间差
      const timeDiff = Math.abs(now - versionStartDate)
      const hoursDiff = timeDiff / (1000 * 60 * 60)

      console.log(`${gameType} ${currentVersion}: 版本开始时间 ${versionStartDate.toLocaleString()}, 时间差 ${hoursDiff.toFixed(2)} 小时`)

      // 如果在24小时内开始，认为是新版本
      if (hoursDiff <= 24) {
        console.log(`🎉 检测到${gameType === 'GI' ? '原神' : '星铁'}版本${currentVersion}在24小时内发布！`)
        return true
      }

      return false
    } catch (error) {
      console.error(`检查${gameType}版本更新失败:`, error)
      return false
    }
  }

  // 获取当前版本的开始时间
  getCurrentVersionStartTime (currentVersion, datesObject) {
    try {
      // 将所有版本按时间排序
      const versionEntries = Object.entries(datesObject)
        .map(([version, [nextVersion, timestamp]]) => ({
          version,
          nextVersion,
          timestamp
        }))
        .sort((a, b) => a.timestamp - b.timestamp)

      // 找到当前版本在排序后的位置
      const currentIndex = versionEntries.findIndex(entry => entry.version === currentVersion)

      if (currentIndex === -1) {
        console.log(`未找到版本 ${currentVersion}`)
        return null
      }

      // 使用前一个版本的时间戳作为当前版本的开始时间
      return versionEntries[currentIndex - 1].timestamp
    } catch (error) {
      console.error('获取版本开始时间失败:', error)
      return null
    }
  }

  // 发送更新通知
  async sendUpdateNotification (updates) {
    try {

      for (const update of updates) {
        const { game, version, gameName } = update

        // 构造改动记录URL
        const changeLogUrl = `https://homdgcat.wiki/Char/${game}/改动汇总/${version}.png`

        // 检查图片是否存在
        const response = await this.makeRequest(changeLogUrl)
        if (response.statusCode === 200) {
          const message = [
            `🎉 ${gameName}版本更新通知！\n`,
            `📋 版本：${version}\n`,
            '🔗 改动记录：\n',
            segment.image(changeLogUrl)
          ]

          await Bot.pickGroup(groupId).sendMsg(message)
          console.log(`已发送${gameName}版本${version}更新通知到群${groupId}`)

          // 记录到Redis，表示该版本已推送
          const redisKey = game === 'GI' ? this.REDIS_KEYS.VERSION_PUSHED_GI : this.REDIS_KEYS.VERSION_PUSHED_HSR
          await redis.set(redisKey, version)
          console.log(`已记录${gameName}版本${version}推送状态到Redis`)
        } else {
          console.log(`${gameName}版本${version}的改动记录图片不存在: ${changeLogUrl}`)
        }
      }
    } catch (error) {
      console.error('发送更新通知失败:', error)
    }
  }

  // 重置推送记录
  async resetPushRecord (e) {
    if (!e.isMaster) {
      e.reply('只有主人才能重置推送记录', true)
      return
    }

    try {
      // 删除Redis中的推送记录
      await redis.del(this.REDIS_KEYS.VERSION_PUSHED_GI)
      await redis.del(this.REDIS_KEYS.VERSION_PUSHED_HSR)

      e.reply('✅ 已重置玉衡杯推送记录，下次检查时会重新推送当前版本（如果符合条件）', true)
      console.log('已重置玉衡杯推送记录')
    } catch (error) {
      console.error('重置推送记录失败:', error)
      e.reply('❌ 重置推送记录失败，请查看控制台日志', true)
    }
  }

  // 手动推送更新（测试用）
  async manualPushUpdate (e) {
    if (!e.isMaster) {
      e.reply('只有主人才能手动推送更新', true)
      return
    }

    try {
      e.reply('🔍 开始手动检查并推送版本更新...', true)

      // 获取版本信息
      const verResponse = await this.makeRequest('https://homdgcat.wiki/javascripts/ver.js')
      const verText = verResponse.body

      // 使用 vm 模块解析 JavaScript 代码
      const context = {}
      vm.createContext(context)
      vm.runInContext(verText, context)

      const { VER_GI, VER_SR, GI_DATES, SR_DATES } = context

      if (!VER_GI || !VER_SR || !GI_DATES || !SR_DATES) {
        e.reply('❌ 无法解析版本信息', true)
        return
      }

      e.reply(`📋 当前版本信息：\n原神: ${VER_GI}\n星铁: ${VER_SR}`, true)

      const updates = []

      // 检查原神版本
      const giChangeLogUrl = `https://homdgcat.wiki/Char/GI/改动汇总/${VER_GI}.png`
      try {
        const giResponse = await this.makeRequest(giChangeLogUrl)
        if (giResponse.statusCode === 200) {
          updates.push({ game: 'GI', version: VER_GI, gameName: '原神', url: giChangeLogUrl })
        } else {
          e.reply(`⚠️ 原神 ${VER_GI} 的改动记录图片不存在`, true)
        }
      } catch (error) {
        e.reply(`❌ 检查原神改动记录失败: ${error.message}`, true)
      }

      // 检查星铁版本
      const hsrChangeLogUrl = `https://homdgcat.wiki/Char/HSR/改动汇总/${VER_SR}.png`
      try {
        const hsrResponse = await this.makeRequest(hsrChangeLogUrl)
        if (hsrResponse.statusCode === 200) {
          updates.push({ game: 'HSR', version: VER_SR, gameName: '星铁', url: hsrChangeLogUrl })
        } else {
          e.reply(`⚠️ 星铁 ${VER_SR} 的改动记录图片不存在`, true)
        }
      } catch (error) {
        e.reply(`❌ 检查星铁改动记录失败: ${error.message}`, true)
      }

      // 发送找到的更新
      if (updates.length > 0) {
        for (const update of updates) {
          const { gameName, version, url } = update
          const message = [
            `🎉 ${gameName}版本更新推送（手动测试）\n`,
            `📋 版本：${version}\n`,
            '🔗 改动记录：\n',
            segment.image(url)
          ]
          await e.reply(message, true)
        }
        e.reply(`✅ 手动推送完成！共推送了 ${updates.length} 个游戏的更新信息`, true)
      } else {
        e.reply('📭 没有找到可用的改动记录图片', true)
      }

    } catch (error) {
      console.error('手动推送更新失败:', error)
      e.reply(`❌ 手动推送更新失败: ${error.message}`, true)
    }
  }

  async main (e) {
    let text = e.raw_message
    // 删除text中的数据
    text = text.replace(/玉衡杯/g, '')
    // 删除text中的空格
    text = text.trim()

    // 检查是否是改动记录查询
    if (text.includes('改动记录')) {
      return await this.getChangeLog(e, text)
    }

    // 原有的角色查询逻辑
    return await this.getCharacterInfo(e, text)
  }

  async getChangeLog (e, text) {
    try {
      // 下载版本信息
      const verResponse = await this.makeRequest('https://homdgcat.wiki/javascripts/ver.js')
      const verText = verResponse.body

      // 判断游戏类型
      let gameType = 'HSR' // 默认星铁
      let currentVer = ''

      if (text.includes('原神')) {
        gameType = 'GI'
        const verMatch = verText.match(/VER_GI = "(.+)"/)
        currentVer = verMatch ? verMatch[1] : ''
      } else {
        // 星铁或默认
        const verMatch = verText.match(/VER_SR = "(.+)"/)
        currentVer = verMatch ? verMatch[1] : ''
      }

      if (!currentVer) {
        e.reply('获取版本信息失败', true, { recallMsg: 5 })
        return
      }

      // 构造改动记录URL
      let url = `https://homdgcat.wiki/Char/${gameType}/改动汇总/${currentVer}.png`

      // 查看url是否存在
      const res = await this.makeRequest(url)
      if (res.statusCode === 200) {
        // 发送图片
        const gameTypeName = gameType === 'GI' ? '原神' : '星铁'
        e.reply([`${gameTypeName}改动记录 ${currentVer}`, segment.image(url)], true)
      } else {
        console.log(`未找到${url}`)
        const gameTypeName = gameType === 'GI' ? '原神' : '星铁'
        e.reply(`未找到 ${gameTypeName}${currentVer} 的改动记录`, true, { recallMsg: 5 })
      }
    } catch (error) {
      console.error('获取改动记录失败:', error)
      e.reply('获取改动记录失败，请稍后重试', true, { recallMsg: 5 })
    }
  }

  async getCharacterInfo (e, text) {
    try {
      // 判断游戏类型 - 支持原神和星铁
      let gameType = 'HSR' // 默认星铁
      let currentVer = ''

      // 下载版本信息
      const verResponse = await this.makeRequest('https://homdgcat.wiki/javascripts/ver.js')
      const verText = verResponse.body

      if (text.includes('原神')) {
        gameType = 'GI'
        // 移除游戏类型关键词
        text = text.replace(/原神/g, '').trim()
        const verMatch = verText.match(/VER_GI = "(.+)"/)
        currentVer = verMatch ? verMatch[1] : ''
      } else if (text.includes('星铁')) {
        gameType = 'HSR'
        // 移除游戏类型关键词
        text = text.replace(/星铁/g, '').trim()
        const verMatch = verText.match(/VER_SR = "(.+)"/)
        currentVer = verMatch ? verMatch[1] : ''
      } else {
        // 默认星铁逻辑（保持向后兼容）
        const verMatch = verText.match(/VER_SR = "(.+)"/)
        currentVer = verMatch ? verMatch[1] : ''
      }

      if (!currentVer) {
        e.reply('获取版本信息失败', true, { recallMsg: 5 })
        return
      }

      // 构造角色信息URL
      let url = `https://homdgcat.wiki/Char/${gameType}/${text}/${currentVer}.png`

      // 查看url是否存在
      const res = await this.makeRequest(url)
      if (res.statusCode === 200) {
        // 发送图片
        e.reply([`${text}${currentVer}`, segment.image(url)], true)
      } else {
        console.log(`未找到${url}`)
        const gameTypeName = gameType === 'GI' ? '原神' : '星铁'
        e.reply(`未找到 ${gameTypeName} ${text}${currentVer} 的数据，请检查是否有错别字`, true, { recallMsg: 5 })
      }
    } catch (error) {
      console.error('获取角色信息失败:', error)
      e.reply('获取角色信息失败，请稍后重试', true, { recallMsg: 5 })
    }
  }
}
